home *** CD-ROM | disk | FTP | other *** search
/ BCI NET / BCI NET Dec 94.iso / archives / programming / libraries / eagui11.lha / EAGUI / EAGUI.doc < prev    next >
Encoding:
Text File  |  1993-12-22  |  25.6 KB  |  727 lines
  1. TABLE OF CONTENTS
  2.  
  3. EAGUI.library/--background--
  4. EAGUI.library/--classes--
  5. EAGUI.library/ea_CreateGadgetList
  6. EAGUI.library/ea_DisposeObject
  7. EAGUI.library/ea_FreeGadgetList
  8. EAGUI.library/ea_GetAttr
  9. EAGUI.library/ea_GetAttrsA
  10. EAGUI.library/ea_GetMinSizes
  11. EAGUI.library/ea_GetObjectLeft
  12. EAGUI.library/ea_GetObjectTop
  13. EAGUI.library/ea_LayoutObjects
  14. EAGUI.library/ea_NewObjectA
  15. EAGUI.library/ea_NewRelationA
  16. EAGUI.library/ea_SetAttr
  17. EAGUI.library/ea_SetAttrsA
  18. EAGUI.library/ea_TextHeight
  19. EAGUI.library/ea_TextLength
  20. EAGUI.library/--background--                     EAGUI.library/--background--
  21.  
  22.    NAME        
  23.         EAGUI.library -- Environment Adaptive Graphic User Interface. (V1)
  24.  
  25.    PURPOSE
  26.         This library was designed to provide a flexible layout engine for
  27.         your graphic interfaces. It uses an object oriented approach to
  28.         provide an abstract definition of the contents of a window. The
  29.         library then can convert this definition into an ordinary list of
  30.         gadgets, which you can use freely. An important design goal was to
  31.         make the interface as transparent as possible. This allows you to
  32.         adapt your existing code easily.
  33.  
  34.    COPYRIGHT
  35.         Environment Adaptive Graphic User Interface
  36.         Copyright © 1993
  37.             Frank Groen
  38.             Marcel Offermans
  39.  
  40. EAGUI.library/--classes--                           EAGUI.library/--classes--
  41.  
  42.    DESCRIPTION
  43.         This is a description of the available classes or object types. It
  44.         particularly describes which tags can be used in which context.
  45.         Although in most cases other tags are ignored, you shouldn't use them
  46.         on objects that don't support them, or you'll be in for some nice
  47.         side effects.
  48.  
  49.         Not all tags can be used under all circumstances. These conditions
  50.         are described in EAGUI.h. Each tag has three flags: I, S and G. If
  51.         all of them are set, you can use this tag at Initialization time
  52.         (when you're using ea_NewObject()), and to Get or Set attributes
  53.         (when using ea_GetAttr() or ea_GetAttrs() and ea_SetAttr() or
  54.         ea_SetAttrs()).
  55.  
  56.         In addition to this documentation, you should also read the GadTools
  57.         and BOOPSI class documentation, to see how these objects work, and
  58.         what tags they need.
  59.  
  60.    TYPE
  61.         global -- Tags that apply to all objects.
  62.  
  63.    TAGS
  64.         EA_Parent - (struct ea_Object *) Pointer to the parent object. The
  65.             current object is linked to this parent.
  66.  
  67.         EA_Type - (ULONG) Type of the object. Normally, you specify this as a
  68.             normal argument when using ea_NewObject().
  69.  
  70.         EA_Disabled - (BOOL) Flag which indicates if the object is disabled
  71.             or not. A disabled object is completely ignored and doesn't take
  72.             up any space. Disabling objects is a simple mechanism for
  73.             temporarily removing the objects from the tree.
  74.  
  75.         EA_ID - (ULONG) ID of the object, which is also copied to any data
  76.             the object generates. Gadgets for example will also have this ID
  77.             stored in their GadgetID field.
  78.  
  79.         EA_MinWidth - (LONG) Minimum width of an object.
  80.  
  81.         EA_MinHeight - (LONG) Minimum height of an object.
  82.  
  83.         EA_BorderLeft - (LONG) Left border thickness of an object.
  84.  
  85.         EA_BorderRight - (LONG) Right border thickness of an object.
  86.  
  87.         EA_BorderTop - (LONG) Top border thickness of an object.
  88.  
  89.         EA_BorderBottom - (LONG) Bottom border thickness of an object.
  90.  
  91.         EA_Left - (LONG) Left offset of an object relative to its parent.
  92.  
  93.         EA_Top - (LONG) Top offset of an object relative to its parent.
  94.  
  95.         EA_Width - (LONG) Actual width of the object.
  96.  
  97.         EA_Height - (LONG) Actual height of the object.
  98.  
  99.         EA_Weight - (ULONG) Weight of the object.
  100.  
  101.         EA_MinSizeMethod - (struct Hook *) Pointer to an initialized Hook for
  102.             the minimum size method. Hooks are described in the
  103.             utility.library. This method takes the following arguments:
  104.  
  105.                 ULONG hookfunction(struct Hook *, struct ea_Object *, APTR);
  106.  
  107.             The third argument is always NULL at the moment. The most
  108.             important argument is the second one, which points at the object
  109.             whose minimum size EAGUI wants determined. For details on how to
  110.             implement such a method, take a look at the tutorial.
  111.  
  112.         EA_BorderMethod - (struct Hook *) Pointer to an initialized Hook for
  113.             the border method. Takes the same hook arguments as the
  114.             EA_MinSizeMethod hook.
  115.  
  116.         EA_RenderMethod - (struct Hook *) Pointer to an initialized Hook for
  117.             the render method. Not implemented.
  118.  
  119.         EA_GetStateMethod - (struct Hook *) Pointer to an initialized Hook
  120.             for the state retrieval method. Not implemented.
  121.  
  122.         EA_SetStateMethod - (struct Hook *) Pointer to an initialized Hook
  123.             for the state restoration method. Not implemented.
  124.  
  125.         EA_FirstChild - (struct ea_Object *) Pointer to the first child of
  126.             the object. Returns NULL if the object has no children.
  127.  
  128.         EA_NextObject - (struct ea_Object *) Pointer to the next object on
  129.             the same level. Returns NULL if there is no next object (ie. when
  130.             the current object is the last object in the list).
  131.  
  132.         EA_StandardMethod - (ULONG) Set of flags, that determine if the
  133.             object should use any standard built-in methods. Flags can be
  134.             OR'ed together. Currently, the following flags are supported:
  135.                 EASM_NONE - Use no standard methods.
  136.                 EASM_MINSIZE - Use a standard method to determine the minimum
  137.                     size of the object.
  138.                 EASM_BORDER - Use a standard method to determine the size of
  139.                     the borders around an object.
  140.  
  141.             Please note that not all object types have standard methods.
  142.             Currently, all GadTools gadgets have EASM_MINSIZE and
  143.             EASM_BORDER methods.
  144.  
  145.  
  146.    TYPE
  147.         EA_TYPE_VGROUP -- A vertical group of objects.
  148.         EA_TYPE_HGROUP -- A horizontal group of objects.
  149.  
  150.    TAGS
  151.         EA_Child - (struct ea_Object *) Pointer to a child object. If you
  152.             pass a NULL pointer here, the whole object creation process will
  153.             fail. This means that if you're creating a group with children,
  154.             and one of them can't be created, the creation of the group will
  155.             also fail.
  156.  
  157.  
  158.    TYPE
  159.         EA_TYPE_GTGADGET -- A GadTools gadget.
  160.  
  161.    TAGS
  162.         EA_Instance - (APTR) Pointer to a generated object. This can be a
  163.             gadget or image pointer, depending on the object type.
  164.  
  165.         EA_InstanceAddress - (APTR *) Address of a pointer where the pointer
  166.             to the generated object is stored.
  167.  
  168.         EA_GTType - (ULONG) Type of the GadTools gadget (#?_KIND) (see also
  169.             gadtools.library/CreateGadget()).
  170.  
  171.         EA_GTTagList - (struct TagItem *) Pointer to an array of tags (see
  172.             also gadtools.library/CreateGadget()).
  173.  
  174.         EA_GTText - (STRPTR) Gadget text (see also
  175.             gadtools.library/CreateGadget()).
  176.  
  177.         EA_GTTextAttr - (struct TextAttr *) Pointer to a text attribute
  178.             structure (see also gadtools.library/CreateGadget()).
  179.  
  180.         EA_GTFlags - (ULONG) Special flags (see also
  181.             gadtools.library/CreateGadget()).
  182.  
  183.  
  184.    TYPE
  185.         EA_TYPE_BOOPSIGADGET -- A BOOPSI gadget.
  186.  
  187.    TAGS
  188.         EA_Instance - (APTR) Pointer to a Gadget structure. In true OO style,
  189.             this should only be used to identify the object. That's why it's
  190.             cast as an APTR.
  191.  
  192.         EA_InstanceAddress - (APTR *) Address of a pointer where the pointer
  193.             to the generated gadget is stored.
  194.  
  195.         EA_BOOPSIPrivClass - (APTR) Pointer to a generated private BOOPSI
  196.             class (see also intuition.library/NewObject()).
  197.  
  198.         EA_BOOPSIPubClass - (STRPTR) Pointer to the name of a public BOOPSI
  199.             class (see also intuition.library/NewObject()).
  200.  
  201.         EA_BOOPSITagList - (struct TagItem *) Pointer to an array of tags.
  202.  
  203.  
  204.    TYPE
  205.         EA_TYPE_CUSTOMIMAGE -- A custom image.
  206.  
  207.    TAGS
  208.         none
  209.  
  210.    NOTES
  211.         Currently, the only image you can use in this context is an empty
  212.         image (ie. no image at all). You can use it as an empty spaceholder,
  213.         and if you want, you can render in its region yourself.
  214.  
  215.  
  216.    TYPE
  217.         EA_TYPE_BOOPSIIMAGE -- (not implemented)
  218.  
  219.    TAGS
  220.         none
  221.  
  222. EAGUI.library/ea_CreateGadgetList           EAGUI.library/ea_CreateGadgetList
  223.  
  224.    NAME        
  225.         ea_CreateGadgetList -- Create the gadgets as defined in the objects
  226.             (V1)
  227.  
  228.    SYNOPSIS
  229.         result = ea_CreateGadgetList(obj_ptr, glist_ptr_ptr, vi_ptr,
  230.         D0                           A0       A1             A2
  231.             draw_ptr)
  232.             A3
  233.  
  234.         LONG ea_CreateGadgetList(struct ea_Object *, struct Gadget **, APTR,
  235.             struct DrawInfo *);
  236.  
  237.    FUNCTION
  238.         This function goes through the tree of objects and creates BOOPSI and
  239.         GadTools gadgets. All gadgets are created using the VisualInfo and
  240.         DrawInfo that are passed as arguments to this function.
  241.  
  242.         The result is a pointer to a gadgetlist, that can be added to a
  243.         window. This pointer will be stored in the address that was passed as
  244.         an argument to this function.
  245.  
  246.    INPUTS
  247.         obj_ptr - Root object of the hierarchical structure to be searched
  248.             for gadgets.
  249.         glist_ptr_ptr - Valid pointer to the place where the pointer to the 
  250.             gadgetlist should be stored.
  251.         vi_ptr - Valid pointer to a VisualInfo structure.
  252.         draw_ptr - Valid pointer to a DrawInfo structure. Note that if you
  253.             do not use any BOOPSI gadgets or images, this pointer may be
  254.             NULL. This is discouraged, and may change in the future.
  255.  
  256.    RESULT
  257.         result - returncode, as defined in EAGUI.h.
  258.  
  259.    SEE ALSO
  260.         ea_FreeGadgetList()
  261.  
  262. EAGUI.library/ea_DisposeObject                 EAGUI.library/ea_DisposeObject
  263.  
  264.    NAME        
  265.         ea_DisposeObject -- Deletes an object. (V1)
  266.  
  267.    SYNOPSIS
  268.         ea_DisposeObject(obj_ptr)
  269.                          A0
  270.  
  271.         VOID ea_DisposeObject(struct ea_Object *);
  272.  
  273.    FUNCTION
  274.         Deletes an object and all of its auxiliary data. These objects are
  275.         all created by ea_NewObject(). Objects of certain classes "own" other
  276.         objects, which will also be deleted when the object is passed to
  277.         ea_DisposeObject(). Read the per-class documentation carefully to be
  278.         aware of these instances.
  279.  
  280.    INPUTS
  281.         obj_ptr - Pointer to the object to be deleted.
  282.  
  283.    SEE ALSO
  284.         ea_NewObject()
  285.  
  286. EAGUI.library/ea_FreeGadgetList               EAGUI.library/ea_FreeGadgetList
  287.  
  288.    NAME        
  289.         ea_FreeGadgetList -- Free all gadgets in a list. (V1)
  290.  
  291.    SYNOPSIS
  292.         ea_FreeGadgetList(obj_ptr, glist_ptr)
  293.                           A0       A1
  294.  
  295.         VOID ea_FreeGadgetList(struct ea_Object *, struct Gadget *);
  296.  
  297.    FUNCTION
  298.         All BOOPSI and GadTools gadgets that were created by
  299.         ea_CreateGadgetList() are cleaned up. It is important that the
  300.         gadgetlist is not connected to a window. The objects are not cleaned
  301.         up.
  302.  
  303.    INPUTS
  304.         obj_ptr - Root object of the hierarchical structure to be searched
  305.             for gadgets.
  306.         glist_ptr - Valid pointer to the the gadgetlist.
  307.  
  308.    SEE ALSO
  309.         ea_CreateGadgetList(), intuition.library/RemoveGList()
  310.  
  311. EAGUI.library/ea_GetAttr                             EAGUI.library/ea_GetAttr
  312.  
  313.    NAME        
  314.         ea_GetAttr -- Inquire the value of an attribute of an object. (V1)
  315.  
  316.    SYNOPSIS
  317.         value = ea_GetAttr(obj_ptr, attribute)
  318.         D0                 A0       D0
  319.  
  320.         ULONG ea_GetAttr(struct ea_Object *, ULONG);
  321.  
  322.    FUNCTION
  323.         Inquires from the specified object the value of an attribute.
  324.  
  325.    INPUTS
  326.         obj_ptr - Pointer to the object.
  327.         attribute - Tag value of the attribute.
  328.  
  329.    RESULT
  330.         value - Value of the attribute.
  331.  
  332.    SEE ALSO
  333.         ea_GetAttrs(), --classes--
  334.  
  335. EAGUI.library/ea_GetAttrsA                         EAGUI.library/ea_GetAttrsA
  336.  
  337.    NAME        
  338.         ea_GetAttrsA -- Inquire the value of some attributes of an object. 
  339.             (V1)
  340.         ea_GetAttrs -- Varargs stub for ea_GetAttrsA(). (V1)
  341.  
  342.    SYNOPSIS
  343.         count = ea_GetAttrsA(obj_ptr, taglist_ptr)
  344.         D0                   A0       A1
  345.  
  346.         ULONG ea_GetAttrsA(struct ea_Object *, struct TagItem *);
  347.  
  348.         count = ea_GetAttrs(obj_ptr, firsttag, ...)
  349.  
  350.         ULONG ea_GetAttrs(struct ea_Object *, ULONG, ...);
  351.  
  352.    FUNCTION
  353.         Inquires from the specified object the value of the attributes
  354.         specified in the taglist.
  355.  
  356.         You always pass the addresses of the long variables, which will
  357.         receive the same value that would be passed to ea_SetAttrs() in the
  358.         ti_Data portion of a TagItem element.
  359.  
  360.         Not all attributes will respond to this function. Those that will are
  361.         documented on a class-by-class basis.
  362.  
  363.         The function returns the number of attributes it obtained. It tries
  364.         to obtain as many attributes as possible, so don't think that if for
  365.         example 3 out of 4 arguments were obtained, that the last one was
  366.         _not_ obtained. It may just as well be the first (or second, or
  367.         third) one.
  368.  
  369.    INPUTS
  370.         obj_ptr - Pointer to the object.
  371.         taglist_ptr - Pointer to the taglist.
  372.  
  373.    RESULT
  374.         count - Number of attributes obtained.
  375.  
  376.    SEE ALSO
  377.         ea_GetAttr(), ea_SetAttrs(), --classes--
  378.  
  379. EAGUI.library/ea_GetMinSizes                     EAGUI.library/ea_GetMinSizes
  380.  
  381.    NAME        
  382.         ea_GetMinSizes -- Calculate minimum object sizes. (V1)
  383.  
  384.    SYNOPSIS
  385.         ea_GetMinSizes(obj_ptr)
  386.                        A0
  387.  
  388.         VOID ea_GetMinSizes(struct ea_Object *);
  389.  
  390.    FUNCTION
  391.         This function calculates the minimum sizes of all of the objects that
  392.         are in the hierarchical tree of which you pass the root object. For
  393.         doing this, ea_GetMinSizes() uses the methods you supplied when
  394.         defining the object tree. A number of methods can be found in the
  395.         EAGUI_METHODS, but it is possible to write your own methods,
  396.         following a few simple rules.
  397.  
  398.         The minimum size of an object does not include the space that is
  399.         needed for its borders.
  400.  
  401.         The minimum sizes are directly filled into the objects. They may only
  402.         be read using ea_GetAttrs().
  403.  
  404.    INPUTS
  405.         obj_ptr - Pointer to the root object of the hierarchical tree. If
  406.             this pointer is NULL, the function returns immediately.
  407.  
  408.    SEE ALSO
  409.         ea_LayoutObjects()
  410.  
  411. EAGUI.library/ea_GetObjectLeft                 EAGUI.library/ea_GetObjectLeft
  412.  
  413.    NAME        
  414.         ea_GetObjectLeft -- Get the left offset to an object (V1)
  415.  
  416.    SYNOPSIS
  417.         left = ea_GetObjectLeft(root_ptr, obj_ptr)
  418.         D0                      A0        A1
  419.  
  420.         LONG ea_GetObjectLeft(struct ea_Object *, struct ea_Object *);
  421.  
  422.    FUNCTION
  423.         This function returns the left offset from the upperleft corner of
  424.         one object to the upperleft corner of another. The second object
  425.         should branch down from the first object. Otherwise the function will
  426.         return garbage. So you have to check yourself!
  427.  
  428.    INPUTS
  429.         root_ptr - Pointer to the object the left offset should be calculated
  430.             from. It should be higher in the hierarchical tree. If this
  431.             pointer is NULL, the function returns immediately.
  432.         obj_ptr - Pointer to the object the left offset should be calculated
  433.             to. It should be lower in the hierarchical tree. If this
  434.             pointer is NULL, the function returns immediately.
  435.  
  436.    RESULT
  437.         left - The left offset from a root object to another object.
  438.  
  439.    SEE ALSO
  440.         ea_GetObjectTop()
  441.  
  442. EAGUI.library/ea_GetObjectTop                   EAGUI.library/ea_GetObjectTop
  443.  
  444.    NAME        
  445.         ea_GetObjectTop -- Get the top offset to an object (V1)
  446.  
  447.    SYNOPSIS
  448.         top = ea_GetObjectTop(root_ptr, obj_ptr)
  449.         D0                    A0        A1
  450.  
  451.         LONG ea_GetObjectTop(struct ea_Object *, struct ea_Object *);
  452.  
  453.    FUNCTION
  454.         This function returns the top offset from the upperleft corner of one
  455.         object to the upperleft corner of another. The second object should
  456.         branch down from the first object. Otherwise the function will return
  457.         garbage. So you have to check yourself!
  458.  
  459.    INPUTS
  460.         root_ptr - Pointer to the object the top offset should be calculated
  461.             from. It should be higher in the hierarchical tree. If this  
  462.             pointer is NULL, the function returns immediately.
  463.         obj_ptr - Pointer to the object the top offset should be calculated
  464.             to. It should be lower in the hierarchical tree. If this  
  465.             pointer is NULL, the function returns immediately.
  466.  
  467.    RESULT
  468.         top - The top offset from a root object to another object.
  469.  
  470.    SEE ALSO
  471.         ea_GetObjectLeft()
  472.  
  473. EAGUI.library/ea_LayoutObjects                 EAGUI.library/ea_LayoutObjects
  474.  
  475.    NAME        
  476.         ea_LayoutObjects -- Calculates the actual object dimensions and
  477.             positions. (V1)
  478.  
  479.    SYNOPSIS
  480.         ea_LayoutObjects(obj_ptr)
  481.                          A0
  482.  
  483.         VOID ea_LayoutObjects(struct ea_Object *);
  484.  
  485.    FUNCTION
  486.         This function calculates the dimensions of all objects in the
  487.         hierarchical tree of which you pass the root object. The dimensions
  488.         of the root object should be filled in before you call this function.
  489.         This function is normally called after you've opened a new window, or
  490.         after someone has resized a window. The minimum sizes of the objects
  491.         should already be calculated, using ea_GetMinSizes().
  492.  
  493.         For every horizontal or vertical group that is in the tree, this
  494.         function does the following. The available height or width of the
  495.         (vertical or horizontal) group object is decreased by the space
  496.         needed for the borders of the child objects. Also the objects with
  497.         weight 0 get their minimum dimensions, and the available space is
  498.         decreased accordingly.
  499.  
  500.         The space that is left, is divided amongst the remaining children.
  501.         Each child gets dimensions depending on its weight factor, but if
  502.         this would result in an object which would be too small, the minimum
  503.         size of the object is used instead. The other dimension of the
  504.         children (the height for horizontal groups, the width for vertical
  505.         ones) is always equal to the height or width of the group object
  506.         decreased by the child objects' borders.
  507.  
  508.         After the space has been divided, the positions of the objects
  509.         relative to their parents are calculated. This position is given as
  510.         an offset from the top-left corner of the parent object to the
  511.         top-left corner of the child object's border. Note that if you want
  512.         to calculate the position of the object itself (again, relative to
  513.         its parent), you should add the left and top border to the offset
  514.         values.
  515.  
  516.    INPUTS
  517.         obj_ptr - Pointer to the root object of the hierarchical tree. If
  518.             this pointer is NULL, the function returns immediately.
  519.  
  520.    SEE ALSO
  521.         ea_GetMinSizes()
  522.  
  523. EAGUI.library/ea_NewObjectA                       EAGUI.library/ea_NewObjectA
  524.  
  525.    NAME        
  526.         ea_NewObjectA -- Create a new object. (V1)
  527.         ea_NewObject -- varargs stub for ea_NewObjectA(). (V1)
  528.  
  529.    SYNOPSIS
  530.         obj_ptr = ea_NewObjectA(type, taglist_ptr)
  531.         D0                      D0    A0
  532.  
  533.         struct ea_Object *ea_NewObjectA(ULONG, struct TagItem *);
  534.  
  535.         obj_ptr = ea_NewObject(type, firsttag, ...)
  536.  
  537.         struct ea_Object *ea_NewObject(ULONG, ULONG, ...);
  538.  
  539.    FUNCTION
  540.         This is the general method of creating objects.
  541.  
  542.         You specify a class by its type, which is passed as a number.
  543.  
  544.         You further specify initial "create-time" attributes for the object
  545.         via a TagItem list, and they are applied to the resulting generic
  546.         data object that is returned. The attributes, their meanings,
  547.         attributes applied only at create-time, and required attributes are
  548.         all defined and documented on a class-by-class basis.
  549.  
  550.    INPUTS
  551.         type - Type of object class you want to create.
  552.         taglist_ptr - Pointer to attay of TagItems containing attribute/value
  553.             pairs to be applied to the object being created.
  554.  
  555.    RESULT
  556.         obj_ptr - An object, which may be manipulated by generic functions.
  557.             You eventually free the object using ea_DisposeObject().
  558.  
  559.    SEE ALSO
  560.         EAGUI.h, EAGUI_macros.h, --classes--
  561.  
  562. EAGUI.library/ea_NewRelationA                   EAGUI.library/ea_NewRelationA
  563.  
  564.    NAME        
  565.         ea_NewRelationA -- Create a new relation. (V1)
  566.         ea_NewRelation -- Varargs stub for ea_NewRelationA. (V1)
  567.  
  568.    SYNOPSIS
  569.         result = ea_NewRelationA(obj_ptr, hook_ptr, taglist_ptr)
  570.         D0                       A0       A1        A2
  571.  
  572.         LONG ea_NewRelationA(struct ea_Object *, struct Hook *,
  573.             struct TagItem *);
  574.  
  575.         result = ea_NewRelation(obj_ptr, hook_ptr, firsttag, ...)
  576.  
  577.         LONG ea_NewRelation(struct ea_Object *, struct Hook *, ULONG, ...);
  578.  
  579.    FUNCTION
  580.         Create a relation between children of obj_ptr. The relation is passed
  581.         through a hook. The children are passed via the tags. Please note
  582.         that these children must all be direct descendants of obj_ptr.
  583.  
  584.         The hook function is called when ea_GetMinSizes() is invoked. Like
  585.         all hooks, it receives the following arguments:
  586.  
  587.             HookFunc(struct Hook *hook_ptr, struct List *list_ptr, APTR
  588.                 msg_ptr)
  589.  
  590.         Currently, the msg_ptr is not used and should be ignored. Your method
  591.         should walk through the list of ea_RelationObjects, and it may modify
  592.         their EA_MinWidth and EA_MinHeight attributes.
  593.  
  594.         Returncodes from the hook function are currently ignored, but you
  595.         should return 0 for success. Future versions may check for
  596.         returncodes.
  597.  
  598.    INPUTS
  599.         obj_ptr - Pointer to the object to which the relation is added.
  600.         hook_ptr - Pointer to a hook containing the relation method.
  601.         taglist_ptr - Pointer to the taglist. The only supported tag is
  602.             EA_Object. The data field should contain a pointer to an
  603.             object.
  604.  
  605.    RESULT
  606.         result - returncode as described in EAGUI.h.
  607.  
  608.    SEE ALSO
  609.         utility/hooks.h
  610.  
  611. EAGUI.library/ea_SetAttr                             EAGUI.library/ea_SetAttr
  612.  
  613.    NAME        
  614.         ea_SetAttr -- Specify attribute value for an object. (V1)
  615.  
  616.    SYNOPSIS
  617.         result = ea_SetAttr(obj_ptr, attribute, value)
  618.         D0                  A0       D0         D1
  619.  
  620.         ULONG ea_SetAttr(struct ea_Object *, ULONG, ULONG);
  621.  
  622.    FUNCTION
  623.         Specifies an attribute/value pair with meaning as defined by
  624.         an object's class.
  625.  
  626.         This function does not provide enough context information or
  627.         arbitration for gadgets which are attached to windows or requesters.
  628.  
  629.    INPUTS
  630.         obj_ptr - Pointer to an object.
  631.         attribute - Tag value of an attribute.
  632.         value - Value of the attribute.
  633.  
  634.    RESULT
  635.         result - Returns 0 for success.
  636.  
  637.    SEE ALSO
  638.         ea_SetAttrs(), --classes--
  639.  
  640. EAGUI.library/ea_SetAttrsA                         EAGUI.library/ea_SetAttrsA
  641.  
  642.    NAME        
  643.         ea_SetAttrsA -- Specify attribute values for an object. (V1)
  644.         ea_SetAttrs -- Varargs stub for ea_SetAttrsA(). (V1)
  645.  
  646.    SYNOPSIS
  647.         result = ea_SetAttrsA(obj_ptr, taglist_ptr)
  648.         D0                    A0       A1
  649.  
  650.         ULONG ea_SetAttrsA(struct ea_Object *, struct TagItem *);
  651.  
  652.         result = ea_SetAttrs(obj_ptr, firsttag, ...)
  653.  
  654.         ULONG ea_SetAttrs(struct ea_Object *, ULONG, ...);
  655.  
  656.  
  657.    FUNCTION
  658.         Specifies a set of attribute/value pairs with meaning as defined by
  659.         an object's class.
  660.  
  661.         This function does not provide enough context information or
  662.         arbitration for gadgets which are attached to windows or requesters.
  663.  
  664.    INPUTS
  665.         obj_ptr - Pointer to an object.
  666.         taglist_ptr - Pointer to an taglist.
  667.  
  668.    RESULT
  669.         result - Returns 0 for success.
  670.  
  671.    SEE ALSO
  672.         ea_SetAttr(), ea_GetAttrs(), --classes--
  673.  
  674. EAGUI.library/ea_TextHeight                       EAGUI.library/ea_TextHeight
  675.  
  676.    NAME        
  677.         ea_TextHeight -- Determine the pixelheight of a text (V1)
  678.  
  679.    SYNOPSIS
  680.         height = ea_TextHeight(textattr_ptr)
  681.         D0                     A0
  682.  
  683.         LONG ea_TextHeight(struct TextAttr *);
  684.  
  685.    FUNCTION
  686.         This function determines the height of the font in pixels.
  687.  
  688.    INPUTS
  689.         textattr_ptr - Pointer to a TextAttr structure.
  690.  
  691.    RESULT
  692.         height - Height in pixels.
  693.  
  694.    SEE ALSO
  695.         ea_TextLength()
  696.  
  697. EAGUI.library/ea_TextLength                       EAGUI.library/ea_TextLength
  698.  
  699.    NAME        
  700.         ea_TextLength -- Determine the pixellength of a string. (V1)
  701.  
  702.    SYNOPSIS
  703.         length = ea_TextLength(textattr_ptr, string_ptr, underscore)
  704.         D0                     A0            A1          D0
  705.  
  706.         LONG ea_TextLength(struct TextAttr *, STRPTR, UBYTE);
  707.  
  708.    FUNCTION
  709.         Determine the pixellength of a given string using the font described
  710.         in the given TextAttr structure. If the string contains an underscore
  711.         character that is used (by GadTools) as an underline marker, set the
  712.         underscore argument to the character that is used as a marker.
  713.  
  714.    INPUTS
  715.         textattr_ptr - Pointer to a TextAttr structure.
  716.         string_ptr - Pointer to the string.
  717.         underscore - ASCII value of the character that is used to indicate an
  718.             underlined character. If you don't want this correction, simply
  719.             pass a value of zero.
  720.  
  721.    RESULT
  722.         length - The pixellength of the string.
  723.  
  724.    SEE ALSO
  725.         ea_TextHeight(), graphics.library/TextLength()
  726.  
  727.